package com.Lemon.Zhkuhealth.admin.controller;

import com.Lemon.Zhkuhealth.common.util.R;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.HashMap;
import java.util.Map;

/**
 * AI 聊天控制器
 * 接入硅基流动（SiliconFlow）大模型 API
 */
@RestController
@RequestMapping("/ai-chat")
@Slf4j
public class ChatController {

    // 从 application.properties 或 application.yml 读取硅基流动 API URL
    @Value("${guiji.api.url}")
    private String guijiApiUrl;

    // 从 application.properties 或 application.yml 读取硅基流动 API Token
    @Value("${guiji.api.token}")
    private String guijiApiToken;

    // 从 application.properties 或 application.yml 读取硅基流动使用的模型名称
    @Value("${guiji.api.model}")
    private String guijiApiModel;

    // 新增：从 application.properties 或 application.yml 读取系统提示词 (可选)
    @Value("${guiji.api.system-prompt:}") // 默认值为空字符串，表示可选
    private String guijiSystemPrompt;

    private final RestTemplate restTemplate;
    private final ObjectMapper objectMapper; // 用于构建和解析JSON

    public ChatController() {
        this.restTemplate = new RestTemplate();
        this.objectMapper = new ObjectMapper();
    }

    /**
     * 处理用户发送的聊天消息，并调用硅基流动 API 获取回复
     * @param requestBody 包含用户消息的请求体，例如 {"message": "我头有点疼"}
     * @return 包含 AI 回复的 R 对象
     */
    @PostMapping("/send")
    public R sendMessage(@RequestBody Map<String, String> requestBody) {
        String userMessage = requestBody.get("message");
        if (userMessage == null || userMessage.trim().isEmpty()) {
            return new R(false, "消息内容不能为空");
        }
        log.info("收到用户消息: {}", userMessage);

        try {
            // 1. 构建硅基流动 API 请求头
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);
            // 根据文档，认证方式为 Authorization: Bearer <token>
            headers.setBearerAuth(guijiApiToken); // 设置 Bearer Token

            ObjectNode rootNode = objectMapper.createObjectNode();
            rootNode.put("model", guijiApiModel); // 设置模型名称

            ArrayNode messagesArray = objectMapper.createArrayNode();

            // 新增逻辑：如果设置了系统提示词，则将其添加到 messages 数组的开头
            if (guijiSystemPrompt != null && !guijiSystemPrompt.trim().isEmpty()) {
                ObjectNode systemMessageNode = objectMapper.createObjectNode();
                systemMessageNode.put("role", "system");
                systemMessageNode.put("content", guijiSystemPrompt);
                messagesArray.add(systemMessageNode);
            }

            // 添加用户消息
            ObjectNode userMessageNode = objectMapper.createObjectNode();
            userMessageNode.put("role", "user");
            userMessageNode.put("content", userMessage);
            messagesArray.add(userMessageNode);

            rootNode.set("messages", messagesArray);
            rootNode.put("stream", false); // 不使用流式传输，获取完整响应

            HttpEntity<String> requestEntity = new HttpEntity<>(rootNode.toString(), headers);

            // 3. 调用硅基流动 API
            String guijiResponseJson = restTemplate.postForObject(guijiApiUrl, requestEntity, String.class);
            log.info("收到硅基流动响应: {}", guijiResponseJson);

            // 4. 解析硅基流动 API 响应
            // 响应内容通常在 choices[0].message.content 字段
            JsonNode responseRoot = objectMapper.readTree(guijiResponseJson);
            String aiReply = "未能获取到AI回复，请检查硅基流动API响应或配置。"; // 默认错误消息

            if (responseRoot.has("choices") && responseRoot.get("choices").isArray()) {
                JsonNode firstChoice = responseRoot.get("choices").get(0);
                if (firstChoice != null && firstChoice.has("message") &&
                        firstChoice.get("message").has("content")) {
                    aiReply = firstChoice.get("message").get("content").asText();
                }
            } else if (responseRoot.has("error")) { // 错误处理
                JsonNode errorNode = responseRoot.get("error");
                if (errorNode.has("message")) {
                    aiReply = "AI 服务错误：" + errorNode.get("message").asText();
                } else {
                    aiReply = "AI 服务返回未知错误。";
                }
                log.error("硅基流动 API 返回错误响应: {}", guijiResponseJson);
                return new R(false, aiReply);
            }

            Map<String, String> data = new HashMap<>();
            data.put("reply", aiReply);
            return new R(true, "消息已处理", data);

        } catch (Exception e) {
            log.error("调用硅基流动 API 失败: {}", e.getMessage(), e);
            return new R(false, "调用AI服务失败，请检查后端日志或配置。");
        }
    }
}